package mutilthread;

/**
 * Created with IntelliJ IDEA.
 * Description: 线程状态
 * User: Li_yizYa
 * Date: 2025—03—21
 * Time: 10:44
 */
public class Demo2 {

    /**
     * WAITING（阻塞状态）：没有超时时间的等待，join/wait
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        Thread mainThread = Thread.currentThread();
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("main state=" + mainThread.getState());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //当前Thread对象虽然有了，但内核的线程还没有（未调用过 start）
        System.out.println(t.getState());//打印线程状态（在t.start之前调用，线程状态是 NEW）

        t.start();

        //由于 t 线程是持续 while 循环，因此join不会返回
        //观察主线程的状态，就能看到 waiting
        t.join();

//        System.out.println(t.getState());
    }
    /**
     * TIMED_WAITING: 有超时时间的等待，比如 sleep 或者 join 带参数的版本
     * @param args
     * @throws InterruptedException
     */
    public static void main3(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        //当前Thread对象虽然有了，但内核的线程还没有（未调用过 start）
        System.out.println(t.getState());//打印线程状态（在t.start之前调用，线程状态是 NEW）

        t.start();

        Thread.sleep(500);
        //TIMED_WAITING（阻塞状态）: 超时等待，调用join
        System.out.println(t.getState());
    }
    /**
     * RUNNABLE
     * @param args
     * @throws InterruptedException
     */
    public static void main2(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {

            }
        });
        //当前Thread对象虽然有了，但内核的线程还没有（未调用过 start）
        System.out.println(t.getState());//打印线程状态（在t.start之前调用，线程状态是 NEW）

        t.start();

        Thread.sleep(500);
        //RUNNABLE: 就绪状态. 正在 cpu 上运行 + 随时可以去 cpu 上运行
        System.out.println(t.getState());
    }
    /**
     * NEW and TERMINATED
     * @param args
     * @throws InterruptedException
     */
    public static void main1(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
//            while (true) {
//                System.out.println("hello");
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
        });
        //当前Thread对象虽然有了，但内核的线程还没有（未调用过 start）
        System.out.println(t.getState());//打印线程状态（在t.start之前调用，线程状态是 NEW）

        t.start();

        Thread.sleep(500);

        //TERMINATED：虽然Thread对象还在，但内核的线程已经销毁（线程已经结束）
        System.out.println(t.getState());
    }
}
